JavaScript'i asünkroonsed generaatorid ja yield: voo juhtimise ja vastusurve meisterlik valdamine

Asünkroonne programmeerimine on kaasaegse JavaScripti arenduse nurgakivi, eriti kui tegemist on I/O-operatsioonide, võrgupäringute ja suurte andmehulkadega. Asünkroonsed generaatorid koos yield-võtmesõnaga pakuvad võimsat mehhanismi asünkroonsete iteraatorite loomiseks, võimaldades tõhusat voo juhtimist ja vastusurve rakendamist. See artikkel süveneb asünkroonsete generaatorite peensustesse ja nende rakendustesse, pakkudes praktilisi näiteid ja rakendatavaid teadmisi.

Asünkroonsete generaatorite mõistmine

Asünkroonne generaator on funktsioon, mis suudab oma täitmise peatada ja seda hiljem jätkata, sarnaselt tavalistele generaatoritele, kuid lisavõimalusega töötada asünkroonsete väärtustega. Peamine eristaja on async-võtmesõna kasutamine enne function-võtmesõna ja yield-võtmesõna väärtuste asünkroonseks väljastamiseks. See võimaldab generaatoril toota väärtuste jada aja jooksul, blokeerimata põhilõime.

Süntaks:

            async function* asyncGeneratorFunction() {
  // Asünkroonsed operatsioonid ja yield-laused
  yield await someAsyncOperation();
}

            

              
                Copy
              
            
          

Vaatame süntaksi lähemalt:

• async function*: Deklareerib asünkroonse generaatorfunktsiooni. Tärn (*) tähistab, et tegemist on generaatoriga.
• yield: Peatab generaatori täitmise ja tagastab väärtuse kutsujale. Kui seda kasutatakse koos await'iga (yield await), ootab see asünkroonse operatsiooni lõpuleviimist enne tulemuse väljastamist.

Asünkroonse generaatori loomine

Siin on lihtne näide asünkroonsest generaatorist, mis toodab asünkroonselt numbrite jada:

            async function* numberGenerator(limit) {
  for (let i = 0; i < limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simuleerib asünkroonset viivitust
    yield i;
  }
}

            

              
                Copy
              
            
          

Selles näites väljastab numberGenerator funktsioon numbri iga 500 millisekundi järel. await-võtmesõna tagab, et generaator peatub, kuni taimaut lõpeb.

Asünkroonse generaatori tarbimine

Asünkroonse generaatori toodetud väärtuste tarbimiseks saate kasutada for await...of-tsüklit:

            async function consumeGenerator() {
  for await (const number of numberGenerator(5)) {
    console.log(number); // Väljund: 0, 1, 2, 3, 4 (igaühe vahel 500ms viivitus)
  }
  console.log('Done!');
}

consumeGenerator();

            

              
                Copy
              
            
          

for await...of-tsükkel itereerib üle asünkroonse generaatori poolt väljastatud väärtuste. await-võtmesõna tagab, et tsükkel ootab iga väärtuse lahendamist enne järgmise iteratsiooniga jätkamist.

Voo juhtimine asünkroonsete generaatoritega

Asünkroonsed generaatorid pakuvad peeneteralist kontrolli asünkroonsete andmevoogude üle. Need võimaldavad teil voogu peatada, jätkata ja isegi lõpetada teatud tingimuste alusel. See on eriti kasulik suurte andmehulkade või reaalajas andmeallikatega tegelemisel.

Voo peatamine ja jätkamine

yield-võtmesõna peatab voo olemuslikult. Saate lisada tingimusloogikat, et kontrollida, millal ja kuidas voogu jätkatakse.

Näide: Piiratud kiirusega andmevoog

            async function* rateLimitedStream(data, rateLimit) {
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, rateLimit));
    yield item;
  }
}

async function consumeRateLimitedStream(data, rateLimit) {
  for await (const item of rateLimitedStream(data, rateLimit)) {
    console.log('Processing:', item);
  }
}

const data = [1, 2, 3, 4, 5];
const rateLimit = 1000; // 1 sekund

consumeRateLimitedStream(data, rateLimit);

            

              
                Copy
              
            
          

Selles näites peatub rateLimitedStream generaator määratud kestuseks (rateLimit) enne iga elemendi väljastamist, kontrollides tõhusalt andmete töötlemise kiirust. See on kasulik allavoolu tarbijate ülekoormamise vältimiseks või API kiiruspiirangutest kinnipidamiseks.

Voo lõpetamine

Asünkroonse generaatori saab lõpetada, lihtsalt funktsioonist tagastades või vea visates. Iteraatori liidese meetodid return() ja throw() pakuvad selgemat viisi generaatori lõpetamise signaalimiseks.

Näide: Voo lõpetamine tingimuse alusel

            async function* conditionalStream(data, condition) {
  for (const item of data) {
    if (condition(item)) {
      console.log('Terminating stream...');
      return;
    }
    yield item;
  }
}

async function consumeConditionalStream(data, condition) {
  for await (const item of conditionalStream(data, condition)) {
    console.log('Processing:', item);
  }
  console.log('Stream completed.');
}

const data = [1, 2, 3, 4, 5];
const condition = (item) => item > 3;

consumeConditionalStream(data, condition);

            

              
                Copy
              
            
          

Selles näites lõpetab conditionalStream generaator töö, kui condition-funktsioon tagastab andmete elemendi kohta true. See võimaldab teil voo töötlemise peatada dünaamiliste kriteeriumide alusel.

Vastusurve asünkroonsete generaatoritega

Vastusurve on oluline mehhanism asünkroonsete andmevoogude haldamiseks, kus tootja genereerib andmeid kiiremini, kui tarbija neid töödelda suudab. Ilma vastusurveta võib tarbija üle koormatud saada, mis toob kaasa jõudluse halvenemise või isegi tõrke. Asünkroonsed generaatorid koos sobivate signaalimismehhanismidega suudavad vastusurvet tõhusalt rakendada.

Vastusurve mõistmine

Vastusurve hõlmab tarbija signaali saatmist tootjale, et andmevoogu aeglustada või peatada, kuni tarbija on valmis rohkem andmeid töötlema. See hoiab ära tarbija ülekoormamise ja tagab ressursside tõhusa kasutamise.

Levinud vastusurve strateegiad:

• Puhverdamine: Tarbija puhverdab sissetulevaid andmeid, kuni neid saab töödelda. See võib aga põhjustada mäluga seotud probleeme, kui puhver liiga suureks kasvab.
• Andmete kaotamine: Tarbija jätab sissetulevad andmed kõrvale, kui ta ei suuda neid kohe töödelda. See sobib stsenaariumide korral, kus andmekadu on vastuvõetav.
• Signaalimine: Tarbija annab tootjale selgesõnaliselt märku andmevoo aeglustamiseks või peatamiseks. See annab kõige rohkem kontrolli ja väldib andmekadu, kuid nõuab tootja ja tarbija vahelist koordineerimist.

Vastusurve rakendamine asünkroonsete generaatoritega

Asünkroonsed generaatorid hõlbustavad vastusurve rakendamist, lubades tarbijal saata signaale tagasi generaatorile next()-meetodi kaudu. Generaator saab seejärel neid signaale kasutada oma andmete tootmiskiiruse reguleerimiseks.

Näide: Tarbijapõhine vastusurve

            async function* producer(consumer) {
  let i = 0;
  while (true) {
    const shouldContinue = await consumer(i);
    if (!shouldContinue) {
      console.log('Producer paused.');
      return;
    }
    yield i++;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simuleerib tööd
  }
}

async function consumer(item) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log('Consumed:', item);
      resolve(item < 10); // Peatub pärast 10 elemendi tarbimist
    }, 500);
  });
}

async function main() {
  const generator = producer(consumer);
  for await (const value of generator) {
    // Tarbija poolel pole loogikat vaja, sellega tegeleb tarbijafunktsioon
  }
  console.log('Stream completed.');
}

main();

            

              
                Copy
              
            
          

Selles näites:

• Funktsioon producer on asünkroonne generaator, mis väljastab pidevalt numbreid. See võtab argumendina consumer-funktsiooni.
• Funktsioon consumer simuleerib andmete asünkroonset töötlemist. See tagastab lubaduse (promise), mis laheneb tõeväärtusega, mis näitab, kas tootja peaks andmete genereerimist jätkama.
• Funktsioon producer ootab enne järgmise väärtuse väljastamist ära consumer-funktsiooni tulemuse. See võimaldab tarbijal anda tootjale vastusurve signaali.

See näide demonstreerib vastusurve põhivormi. Keerukamad rakendused võivad hõlmata puhverdamist tarbija poolel, dünaamilist kiiruse reguleerimist ja veatöötlust.

Täiustatud tehnikad ja kaalutlused

Veatöötlus

Veatöötlus on asünkroonsete andmevoogudega töötamisel ülioluline. Asünkroonse generaatori sees saate kasutada try...catch-plokke, et püüda ja käsitleda vigu, mis võivad tekkida asünkroonsete operatsioonide käigus.

Näide: Veatöötlus asünkroonses generaatoris

            async function* errorProneGenerator() {
  try {
    const result = await someAsyncOperationThatMightFail();
    yield result;
  } catch (error) {
    console.error('Error:', error);
    // Otsustage, kas visata viga uuesti, väljastada vaikeväärtus või lõpetada voog
    yield null; // Väljastage vaikeväärtus ja jätkake
    //throw error;  // Visake viga uuesti, et voog lõpetada
    //return;       // Lõpetage voog sujuvalt
  }
}

            

              
                Copy
              
            
          

Samuti saate kasutada iteraatori throw()-meetodit, et süstida viga generaatorisse väljastpoolt.

Voogude teisendamine

Asünkroonseid generaatoreid saab aheldada, et luua andmetöötlustorustikke. Saate luua funktsioone, mis teisendavad ühe asünkroonse generaatori väljundi teise sisendiks.

Näide: Lihtne teisendustorustik

            async function* mapStream(source, transform) {
  for await (const item of source) {
    yield transform(item);
  }
}

async function* filterStream(source, filter) {
  for await (const item of source) {
    if (filter(item)) {
      yield item;
    }
  }
}

// Näide kasutamisest:
async function main() {
  async function* numberGenerator(limit) {
    for (let i = 0; i < limit; i++) {
      yield i;
    }
  }

  const source = numberGenerator(10);
  const doubled = mapStream(source, (x) => x * 2);
  const evenNumbers = filterStream(doubled, (x) => x % 2 === 0);

  for await (const number of evenNumbers) {
    console.log(number); // Väljund: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18
  }
}

main();

            

              
                Copy
              
            
          

Selles näites teisendavad ja filtreerivad funktsioonid mapStream ja filterStream andmevoogu vastavalt. See võimaldab teil luua keerukaid andmetöötlustorustikke, kombineerides mitmeid asünkroonseid generaatoreid.

Võrdlus teiste voogedastuse lähenemisviisidega

Kuigi asünkroonsed generaatorid pakuvad võimsat viisi asünkroonsete voogude käsitlemiseks, on olemas ka teisi lähenemisviise, nagu JavaScripti voogude API (ReadableStream, WritableStream jne) ja teegid nagu RxJS. Igal lähenemisviisil on oma tugevused ja nõrkused.

• Asünkroonsed generaatorid: Pakuvad suhteliselt lihtsat ja intuitiivset viisi asünkroonsete iteraatorite loomiseks ja vastusurve rakendamiseks. Need sobivad hästi stsenaariumideks, kus vajate voo üle peeneteralist kontrolli ega vaja reaktiivse programmeerimise teegi täit võimsust.
• JavaScripti voogude API: Pakuvad standardsemat ja jõudlusvõimelisemat viisi voogude käsitlemiseks, eriti veebilehitsejas. Neil on sisseehitatud tugi vastusurvele ja erinevatele voo teisendustele.
• RxJS: Võimas reaktiivse programmeerimise teek, mis pakub rikkalikku operaatorite komplekti asünkroonsete andmevoogude teisendamiseks, filtreerimiseks ja kombineerimiseks. See sobib hästi keerukateks stsenaariumideks, mis hõlmavad reaalajas andmeid ja sündmuste käsitlemist.

Lähenemisviisi valik sõltub teie rakenduse konkreetsetest nõuetest. Lihtsate voogude töötlemise ülesannete jaoks võivad asünkroonsed generaatorid olla piisavad. Keerukamate stsenaariumide jaoks võivad sobivamad olla JavaScripti voogude API või RxJS.

Reaalse maailma rakendused

Asünkroonsed generaatorid on väärtuslikud mitmesugustes reaalsetes stsenaariumides:

• Suurte failide lugemine: Lugege suuri faile tükkhaaval, laadimata kogu faili mällu. See on ülioluline failide töötlemiseks, mis on suuremad kui saadaolev RAM. Mõelge stsenaariumidele, mis hõlmavad logifailide analüüsi (nt veebiserveri logide analüüsimine turvaohtude tuvastamiseks geograafiliselt hajutatud serverites) või suurte teaduslike andmekogumite töötlemist (nt genoomiandmete analüüs, mis hõlmab mitmes kohas salvestatud petabaite teavet).
• Andmete pärimine API-dest: Rakendage lehitsemist (pagination) andmete pärimisel API-dest, mis tagastavad suuri andmekogumeid. Saate andmeid pärida partiidena ja väljastada iga partii selle kättesaadavaks muutumisel, vältides API-serveri ülekoormamist. Mõelge stsenaariumidele, nagu e-kaubanduse platvormid, mis hangivad miljoneid tooteid, või sotsiaalmeedia saidid, mis voogedastavad kasutaja kogu postituste ajalugu.
• Reaalajas andmevood: Töödelge reaalajas andmevooge allikatest nagu WebSockets või server-sent events. Rakendage vastusurvet, et tagada tarbija suutlikkus andmevooga sammu pidada. Mõelge finantsturgudele, mis saavad aktsiahindade andmeid mitmelt ülemaailmselt börsilt, või asjade interneti anduritele, mis edastavad pidevalt keskkonnaandmeid.
• Andmebaasi interaktsioonid: Voogedastage päringutulemusi andmebaasidest, töödeldes andmeid rida-realt, selle asemel et laadida kogu tulemuste hulk mällu. See on eriti kasulik suurte andmebaasitabelite puhul. Mõelge stsenaariumidele, kus rahvusvaheline pank töötleb miljonite kontode tehinguid või ülemaailmne logistikaettevõte analüüsib tarneteid üle mandrite.
• Pildi- ja videotöötlus: Töödelge pildi- ja videoandmeid tükkidena, rakendades vastavalt vajadusele teisendusi ja filtreid. See võimaldab teil töötada suurte meediumifailidega ilma mälupiiranguteta. Mõelge satelliidipiltide analüüsile keskkonnaseireks (nt metsaraie jälgimine) või mitme turvakaamera valvekaadrite töötlemisele.

Kokkuvõte

JavaScripti asünkroonsed generaatorid pakuvad võimsat ja paindlikku mehhanismi asünkroonsete andmevoogude käsitlemiseks. Kombineerides asünkroonseid generaatoreid yield-võtmesõnaga, saate luua tõhusaid iteraatoreid, rakendada voo juhtimist ja hallata vastusurvet efektiivselt. Nende kontseptsioonide mõistmine on oluline vastupidavate ja skaleeritavate rakenduste loomiseks, mis suudavad hakkama saada suurte andmehulkade ja reaalajas andmevoogudega. Kasutades selles artiklis käsitletud tehnikaid, saate optimeerida oma asünkroonset koodi ning luua reageerimisvõimelisemaid ja tõhusamaid rakendusi, sõltumata teie kasutajate geograafilisest asukohast või konkreetsetest vajadustest.